#ifndef __M_WSSERVER_H__
#define __M_WSSERVER_H__

// 一个matcher.hpp已经包含多个头文件了
#include "matcher.hpp"
#include "session.hpp"

#define WWWROOT "./wwwroot/"

// 服务器类包含前面所有实现的模块的句柄
class gobang_server
{
private:
    std::string _web_root; // web根目录(静态资源根目录，存放前端请求的html/css/js等静态文件资源)
    // 客户端向服务器请求静态资源文件，服务器给客户端返回一个静态资源文件，这个前端文件在客户端的浏览器上就可以渲染展示出来
    user_table _ut;
    online_manager _om;
    room_manager _rm;
    match_manager _mm; // match manager
    wsserver_t _wssvr; // websocket/http服务器对象，有默认构造函数，不用初始化(无参构造websocket服务器对象)
    session_manager _sm;
    // 1.成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
    // 2.初始化顺序: _web_root > _ut > _om > _rm > _mm > _wssvr > _sm
    // 3._ut依赖外部传入的参数进行初始化，_om有默认构造，_rm依赖_ut和_om进行初始化，_mm依赖_rm和_ut和_om进行初始化，_wssvr有默认构造，
    //   _sm依赖_wssvr进行初始化
private:
    // websocket服务器的四个私有回调函数
    void static_handler(wsserver_t::connection_ptr &conn)
    {
        // 静态资源请求的处理
        // 1.获取请求uri(请求资源路径)，得到客户端请求的页面文件的名称
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        // 2.组合出文件的实际路径(文件在linux服务器上的实际路径)
        std::string realPath = _web_root + uri; //./wwwroot/ + uri(/xxx.html 或 / 或 空)
        // 3.如果请求的是个目录，则我们默认增加一个后缀名 login.html
        if (realPath.back() == '/')
            realPath += "login.html";
        // 4.读取文件内容(如果客户端请求的文件不存在，则服务器返回404)
        std::string body;
        bool ret = file_util::read(realPath, body);
        if (ret == false)
        {
            body += "<html><head> <meta charset='UTF-8'> </head> <body><h1>Not Found</h1> </body></html>";
            conn->set_status(websocketpp::http::status_code::value::not_found);
            conn->set_body(body); // 返回一个展示Not Found的响应正文body，响应状态码是404
            return;
        }
        // 5.设置响应正文
        conn->set_status(websocketpp::http::status_code::value::ok);
        conn->set_body(body);
    }
    void respHttp_JsonFormat(bool result, websocketpp::http::status_code::value code,
                             const std::string &reason, wsserver_t::connection_ptr &conn)
    {
        Json::Value resp_json;
        resp_json["result"] = result;
        resp_json["reason"] = reason;
        std::string resp_body;
        json_util::serialize(resp_json, resp_body);
        conn->set_status(code);
        conn->append_header("Content-Type", "application/json"); // 返回的响应类型是json格式的字符串
        conn->set_body(resp_body);
        return;
    }
    void register_handler(wsserver_t::connection_ptr &conn) // 传递连接指针，获取不同的请求，进行不同的处理
    {
        // 用户注册功能请求的处理
        // 1.获取到客户端的json组织的请求字符串
        std::string req_body = conn->get_request_body();
        // 2.对客户端发送的json格式的请求字符串消息，进行json格式的反序列化得到用户名和密码(反序列化可能成功，也可能失败)
        Json::Value reg_info; // 序列化后的用户名和密码(json格式组织的数据)
        bool ret = json_util::deserialize(req_body, reg_info);
        if (ret == false)
        {
            DLOG("反序列化注册信息失败");
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "请求的正文格式错误", conn);
            return;
        }
        // 3.通过数据管理模块句柄来进行用户的添加(添加可能成功，可能失败)
        if (reg_info["username"].isNull() || reg_info["password"].isNull())
        {
            DLOG("用户名/密码不完整");
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "请输入用户名/密码", conn);
            return;
        }
        ret = _ut.insert(reg_info);
        if (ret == false)
        {
            DLOG("用户名已经存在，向数据库中添加用户失败");
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "用户名已经被占用", conn);
            return;
        }
        // 成功返回的状态码是200，不成功返回的是400
        respHttp_JsonFormat(true, websocketpp::http::status_code::value::ok, "用户注册成功", conn);
        return;
    }
    void login_handler(wsserver_t::connection_ptr &conn)
    {
        // 用户登录功能请求的处理
        // 1.获取客户端发来的json格式的请求正文
        std::string req_body = conn->get_request_body();
        // 2.对json格式的请求正文进行反序列化，拿到用户名和密码字段
        Json::Value reg_info;
        bool ret = json_util::deserialize(req_body, reg_info);
        if (ret == false)
        {
            DLOG("反序列化登录信息失败");
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "请求的正文格式错误", conn);
            return;
        }
        // 3.校验请求正文的完整性，看看用户名和密码有没有没输入的
        if (reg_info["username"].isNull() || reg_info["password"].isNull())
        {
            DLOG("用户名/密码不完整");
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "请输入用户名/密码", conn);
            return;
        }
        // 4.若请求正文完整，则进行数据库的用户信息验证(若验证失败，返回400状态码)
        ret = _ut.login(reg_info); // 若登录成功，则会将完整的用户信息返回到reg_info里面
        if (ret == false)
        {
            DLOG("用户名/密码错误，请重新输入");
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "用户名/密码错误，请重新输入", conn);
            return;
        }
        // 5.若验证成功，则需要先判断会话是否存在，如果存在，则刷新销毁时间。
        int uid = reg_info["id"].asInt();
        session_ptr sp = _sm.is_session_exists(uid);
        if(sp.get() != nullptr)
        {
            _sm.set_session_expire_time(sp->ssid(), SESSION_TIMEOUT);
            std::string cookie_ssid = "SSID=" + std::to_string(sp->ssid());
            conn->append_header("Set-Cookie", cookie_ssid);
            respHttp_JsonFormat(true, websocketpp::http::status_code::value::ok, "登录成功", conn);
            return;
        }
        //如果不存在，我们才会去创建新会话
        uid = reg_info["id"].asInt();
        sp = _sm.create_session(uid, login);
        if (sp.get() == nullptr)
        {
            DLOG("创建session失败");
            // 服务器内部错误，响应状态码为500
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::internal_server_error, "创建session失败", conn);
            return;
        }
        _sm.set_session_expire_time(sp->ssid(), SESSION_TIMEOUT); // 会话创建成功后，设置会话的过期时间
        // 6.创建session完成后，构建响应(将ssid通过响应的头部字段Set-Cookie返回)，返回给客户端
        std::string cookie_ssid = "SSID=" + std::to_string(sp->ssid());
        conn->append_header("Set-Cookie", cookie_ssid);
        respHttp_JsonFormat(true, websocketpp::http::status_code::value::ok, "登录成功", conn);
        return;
    }
    bool get_val_from_cookie_by_key(const std::string &cookie_str, const std::string &key, std::string &val)
    {
        // http请求头部字段Cookie格式:
        // Cookie: name=value; name2=value2; name3=value3
        // 1.以"; "作为间隔，对字符串进行分割，得到单个的cookie信息
        std::vector<std::string> cookies;
        string_util::split(cookie_str, "; ", cookies);
        // 2.对单个的cookie信息，以"="作为间隔，得到key和value
        for (auto str : cookies)
        {
            std::vector<std::string> tmp_arr;
            string_util::split(str, "=", tmp_arr);
            if (tmp_arr.size() != 2)
                continue;
            // 3.如果key和传入的key相同，则将value赋值给输出型参数val即可
            if (tmp_arr.front() == key)
            {
                val = tmp_arr.back();
                return true;
            }
        }
        return false;
    }
    void info_handler(wsserver_t::connection_ptr &conn)
    {
        // 用户信息获取功能请求的处理
        // 1.获取客户端发来的json格式请求中的Cookie字段，从cookie中获取ssid
        std::string cookie_str = conn->get_request_header("Cookie"); // 根据指定头部字段，拿到请求正文的字段值
        if (cookie_str.empty())
        {
            // (如果没有Cookie，则直接返回错误响应信息)
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "找不到Cookie信息，请重新登录", conn);
            return;
        }
        std::string ssid_str;
        bool ret = get_val_from_cookie_by_key(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "找不到ssid信息，请重新登录", conn);
            return;
        }
        // 2.在session管理中查找对应的会话信息
        session_ptr sp = _sm.get_session_by_ssid(std::stoi(ssid_str));
        if (sp.get() == nullptr)
        {
            // (没有找到session，则认为登录已经过期，需要用户重新登录)
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "登陆过期，请重新登录", conn);
            return;
        }
        // 3.如果能够找到对应的会话，则说明用户此时就是登录状态，则从数据库中取出用户详细信息
        int uid = sp->get_uid();
        Json::Value user_info;
        ret = _ut.select_by_id(uid, user_info);
        if (ret == false)
        {
            // 获取用户信息失败，返回错误：找不到用户信息(算服务器错误吧!)
            respHttp_JsonFormat(false, websocketpp::http::status_code::value::bad_request, "找不到用户信息，请重新登录", conn);
            return;
        }
        // 4.将获取到的用户详细信息进行序列化发送给客户端
        std::string resp_body;
        json_util::serialize(user_info, resp_body);
        conn->append_header("Content-Type", "application/json");
        conn->set_body(resp_body);
        conn->set_status(websocketpp::http::status_code::value::ok);
        // 5.刷新session的过期时间，因为客户端和服务器交互了一次，session应该被刷新
        _sm.set_session_expire_time(sp->ssid(), SESSION_TIMEOUT);
    }

    void http_callback(websocketpp::connection_hdl hdl) // http请求的回调函数
    {
        //---客户端的http请求分为两类: 静态资源请求 + 动态功能请求

        wsserver_t::connection_ptr conn = _wssvr.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request(); // 获取http请求信息
        std::string method = req.get_method();
        std::string uri = req.get_uri();
        // 根据method和uri的不同，区分出静态资源请求 和 动态功能请求
        if (method == "POST" && uri == "/reg")
        {
            register_handler(conn);
        }
        else if (method == "POST" && uri == "/login")
        {
            login_handler(conn);
        }
        else if (method == "GET" && uri == "/userinfo")
        {
            info_handler(conn);
        }
        else
        {
            static_handler(conn);
        }
        return;
    }
    void respSend_JsonFormat(Json::Value resp, wsserver_t::connection_ptr conn)
    {
        std::string body;
        json_util::serialize(resp, body);
        conn->send(body);
        return;
    }
    session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn)
    {
        Json::Value err_resp;
        // 1.1 登陆验证(判断当前客户端是否已经登陆成功 等价于 会话信息是否存在)
        std::string cookie_str = conn->get_request_header("Cookie"); // 根据指定头部字段，拿到请求正文的字段值
        if (cookie_str.empty())
        {
            // (如果没有Cookie，则直接返回错误响应信息)
            err_resp["optype"] = "hall_ready";
            err_resp["result"] = false;
            err_resp["reason"] = "没有找到cookie信息，请重新登录";
            respSend_JsonFormat(err_resp, conn);
            return session_ptr();
        }
        std::string ssid_str;
        bool ret = get_val_from_cookie_by_key(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            err_resp["optype"] = "hall_ready";
            err_resp["result"] = false;
            err_resp["reason"] = "找不到SSID信息，请重新登录";
            respSend_JsonFormat(err_resp, conn);
            return session_ptr();
        }
        // 1.2 在session管理中查找对应的会话信息
        session_ptr sp = _sm.get_session_by_ssid(std::stoi(ssid_str));
        if (sp.get() == nullptr)
        {
            // (没有找到session，则认为登录已经过期，需要用户重新登录)
            err_resp["optype"] = "hall_ready";
            err_resp["result"] = false;
            err_resp["reason"] = "没有找到session信息，请重新登录";
            respSend_JsonFormat(err_resp, conn);
            return session_ptr();
        }
        return sp;
    }
    void wsopen_game_hall(wsserver_t::connection_ptr conn)// 游戏大厅长连接建立成功
    {
        Json::Value resp_json;
        session_ptr sp = get_session_by_cookie(conn);
        if(sp.get() == nullptr) return;
        // 2.判断当前客户端是否是重复登陆(如果用户已经在游戏大厅或游戏房间，那么说明用户现在的登录是重复登陆)
        if (_om.is_in_game_hall(sp->get_uid()) || _om.is_in_game_room(sp->get_uid()))
        {
            resp_json["optype"] = "hall_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "玩家重复登陆";
            respSend_JsonFormat(resp_json, conn);
            return;
        }
        // 3.将当前客户端以及连接加入到游戏大厅在线用户管理模块中
        _om.enter_game_hall(sp->get_uid(), conn);
        // 4.给客户端响应游戏大厅长连接建立成功
        resp_json["optype"] = "hall_ready";
        resp_json["result"] = true;
        respSend_JsonFormat(resp_json, conn);
        // 5.不要忘记将session设置为永久存在
        _sm.set_session_expire_time(sp->ssid(), SESSION_PERMANENT);
        return;
    }
    void wsopen_game_room(wsserver_t::connection_ptr conn)
    {
        //1.获取当前客户端的session
        Json::Value resp_json;
        session_ptr sp = get_session_by_cookie(conn);
        if(sp.get() == nullptr) return;
        //2.判断当前用户是否已经在线了(例如在其他的游戏房间或者还在游戏大厅中，)
        //  如果在，则说明用户进行了二次页面的获取，我们不允许一个用户已经在一个房间中了，然后又去请求别的房间
        if(_om.is_in_game_hall(sp->get_uid()) || _om.is_in_game_room(sp->get_uid()))
        {
            resp_json["optype"] = "room_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "玩家重复登陆";
            respSend_JsonFormat(resp_json, conn);
            return;            
        }
        //3.判断当前用户是否已经创建好了房间
        room_ptr rp = _rm.get_room_by_uid(sp->get_uid());
        if(rp.get() == nullptr) 
        {
            resp_json["optype"] = "room_ready";
            resp_json["result"] = false;
            resp_json["reason"] = "没有找到玩家的房间信息!";
            respSend_JsonFormat(resp_json, conn);
            return;              
        }
        //4.将当前用户添加到游戏房间在线用户管理模块
        _om.enter_game_room(sp->get_uid(), conn);
        //5.将session重新设置为永久存在
        _sm.set_session_expire_time(sp->ssid(), SESSION_PERMANENT);
        //6.给客户端回复游戏房间准备完毕的json响应
        resp_json["optype"] = "room_ready";
        resp_json["result"] = true;
        resp_json["room_id"] = rp->get_room_id();
        resp_json["self_id"] = sp->get_uid();
        resp_json["black_id"] = rp->get_black_user();
        resp_json["white_id"] = rp->get_white_user();
        respSend_JsonFormat(resp_json, conn);
        return;           
    }
    void wsopen_callback(websocketpp::connection_hdl hdl) // websocket连接建立成功的回调函数
    {
        // websocket长连接建立成功后的回调函数(根据uri资源路径的不同来区分长连接是hall还是room)
        wsserver_t::connection_ptr conn = _wssvr.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request(); // 获取http请求信息
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            // 建立游戏大厅的长连接
            wsopen_game_hall(conn);
            return;
        }
        else if (uri == "/room")
        {
            // 建立游戏房间的长连接
            wsopen_game_room(conn);
            return;
        }
    }
    void wsclose_game_hall(wsserver_t::connection_ptr conn)// 游戏大厅长连接断开的处理
    {
        session_ptr sp = get_session_by_cookie(conn);
        if(sp.get() == nullptr) return;
        
        // 1.将玩家从游戏大厅中移除
        _om.exit_game_hall(sp->get_uid());
        // 2.将session从永久存在设置为定时销毁
        _sm.set_session_expire_time(sp->ssid(), SESSION_TIMEOUT);
    }
    void wsclose_game_room(wsserver_t::connection_ptr conn)//关闭游戏房间长连接
    {
        //1.获取会话信息识别客户端
        session_ptr sp = get_session_by_cookie(conn);
        if(sp.get() == nullptr) return;
        //2.将玩家从游戏房间在线用户管理模块中移除
        _om.exit_game_room(sp->get_uid());
        //3.将session设置为定时销毁
        _sm.set_session_expire_time(sp->ssid(), SESSION_TIMEOUT);
        //4.将玩家从游戏房间中移除，房间中所有用户退出了，则会自动销毁房间
        _rm.remove_room_user(sp->get_uid());
    }
    void wsclose_callback(websocketpp::connection_hdl hdl) // websocket连接断开的回调函数
    {
        // 1.websocket连接断开前的处理(要区分是游戏大厅长连接断开，还是游戏房间长连接断开)
        wsserver_t::connection_ptr conn = _wssvr.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request(); // 获取http请求信息
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            // 关闭游戏大厅的长连接
            wsclose_game_hall(conn);
            return;
        }
        else if (uri == "/room")
        {
            // 关闭游戏房间的长连接
            wsclose_game_room(conn);
            return;
        }
    }
    void wsmessage_game_hall(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msgptr)
    {
        Json::Value resp_json;
        //1.判断连接请求的客户端是谁？(通过cookie拿到会话id，通过会话id拿到会话详细信息，通过会话信息拿到uid，这样就判断出客户端是谁了)
        session_ptr sp = get_session_by_cookie(conn);
        if(sp.get() == nullptr) return;

        //2.获取请求信息，判断请求业务的类型
        std::string req_body = msgptr->get_payload();
        Json::Value req_json;
        bool ret = json_util::deserialize(req_body, req_json);
        if(ret == false)
        {
            resp_json["result"] = false;
            resp_json["reason"] = "请求信息解析失败";
            respSend_JsonFormat(resp_json, conn);
            return;
        }
        //3.对游戏大厅中的业务请求进行处理，业务请求只有两种: 开始对战匹配 vs 停止对战匹配
        if(!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start")
        {
            //3.1 开始对战匹配: 通过匹配队列模块，将用户添加到对应的匹配队列中
            _mm.add(sp->get_uid());
            resp_json["optype"] = "match_start";
            resp_json["result"] = true;
            respSend_JsonFormat(resp_json, conn);
            return;
        }
        else if(!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop")
        {
            //3.2 停止对战匹配: 通过匹配队列模块，将用户从对应的匹配队列中移除
            _mm.del(sp->get_uid());
            resp_json["optype"] = "match_stop";
            resp_json["result"] = true;
            respSend_JsonFormat(resp_json, conn);//给客户端返回响应
            return;            
        }    
        resp_json["optype"] = "unknown";
        resp_json["reason"] = "请求类型未知";
        resp_json["result"] = false;
        respSend_JsonFormat(resp_json, conn);
        return;
    }
    void wsmessage_game_room(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msgptr)
    {
        Json::Value resp_json;
        //1.获取客户端session，识别客户端身份
        session_ptr sp = get_session_by_cookie(conn);
        if(sp.get() == nullptr) return;
        //2.获取客户端的游戏房间信息
        room_ptr rp = _rm.get_room_by_uid(sp->get_uid());
        if(rp.get() == nullptr) 
        {
            resp_json["optype"] = "unknown";
            resp_json["result"] = false;
            resp_json["reason"] = "没有找到玩家的房间信息!";
            respSend_JsonFormat(resp_json, conn);
            return;              
        }
        //3.对请求字符串进行反序列化
        Json::Value req_json;
        std::string req_body = msgptr->get_payload();
        bool ret = json_util::deserialize(req_body, req_json);
        if(ret == false)
        {
            resp_json["result"] = false;
            resp_json["reason"] = "请求信息解析失败";
            respSend_JsonFormat(resp_json, conn);
            return;
        }
        //4.通过游戏房间管理模块，对req_json进行后端业务处理
        rp->handle_request(req_json);//游戏房间中请求业务的种类较多，我们将多个业务的处理放到了后端的游戏房间模块当中
        return;
    }
    void wsmessage_callback(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msgptr) // websocket通信的回调函数
    {
        //websocket通信处理
        wsserver_t::connection_ptr conn = _wssvr.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request(); // 获取http请求信息
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            wsmessage_game_hall(conn, msgptr);
            return;
        }
        else if (uri == "/room")
        {
            wsmessage_game_room(conn, msgptr);
            return;
        }
    }

public:
    // 完成成员变量的初始化 + 服务器回调函数的设置
    gobang_server(const std::string &host, const std::string &username, const std::string &password,
                  const std::string &dbname, uint16_t port = 3306, const std::string &wwwroot = WWWROOT)
        : _ut(host, username, password, dbname, port), _web_root(wwwroot), _mm(&_rm, &_ut, &_om), _rm(&_ut, &_om), _sm(&_wssvr)
    {
        // 2.设置日志等级为none
        _wssvr.set_access_channels(websocketpp::log::alevel::none);
        // 3.初始化asio异步IO调度器
        _wssvr.init_asio();
        _wssvr.set_reuse_addr(true);
        // 4.设置WebSocket服务器的事件处理回调函数
        //  websocketpp中的标准函数声明:
        //  -> void set_http_handler(http_handler h);  typedef lib::function<void(connection_hdl)> http_handler;
        // 5.bind的用法有两种，一种是绑死参数，调用bind生成的可调用对象时，无论传什么参数都没用，因为bind已经绑死参数了
        //   另一种是预留参数位置，等待bind生成的可调用对象在被调用时进行实际传参!
        // -> bind不影响传递绑定对象作为参数传递时的类型，只影响调用时的实际传参
        // -> bind是function的适配器，只要bind生成的可调用对象，可以作为参数传递给其他API的任意类型的function对象参数!(---这就是适配器模式)
        _wssvr.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));
        _wssvr.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));
        _wssvr.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));
        _wssvr.set_message_handler(std::bind(&gobang_server::wsmessage_callback, this, std::placeholders::_1, std::placeholders::_2));
    }
    ~gobang_server() {}
    void run(int port) // 启动服务器
    {
        // 5.设置服务器绑定的监听端口号，监听端口号上是否有连接到来
        _wssvr.listen(port);
        // 6.accept获取内核监听队列中已经完成三次握手的连接，开始通信
        _wssvr.start_accept();
        // 7.启动运行WebSocket服务器
        _wssvr.run();
    }
};

#endif